// <copyright file="BlockEditor.cs" company="Largo">
// Copyright (c) 2009 All Right Reserved
// </copyright>
// <author> vl </author>
// <email></email>
// <date>2009-01-01</date>
// <summary>Contains ...</summary>

namespace LargoEditor.Abstract {
    using LargoBase.Abstract;
    using LargoBase.Enums;
    using LargoBase.Localization;
    using LargoBase.Midi;
    using LargoBase.Music;
    using LargoKernel;
    using LargoKernel.Blocks;
    using LargoKernel.Board;
    using LargoKernel.Composer;
    using LargoKernel.Patterns;
    using LargoModels;
    using System.Collections.Generic;
    using System.Diagnostics.Contracts;
    using System.IO;
    using System.Linq;

    /// <summary>
    /// Musical Editor.
    /// </summary>
    public sealed class BlockEditor {
        #region Fields
        //// Prepared for the future

        /// <summary>
        /// Max Editor Lines.
        /// </summary>
        //// private const int MaxEditorLines = 250;

        /// <summary>
        /// Max Editor Bars.
        /// </summary>
        //// private const int MaxEditorBars = 2500;

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="BlockEditor"/> class.
        /// </summary>
        public BlockEditor() {
            this.MusicalSelection = new MusicalSelection();
            this.EditorContent = EditorContent.NumberOfTones;
            this.EditorColor = EditorColor.RhythmicDensity;
        }

        #endregion

        #region Public static properties

        /// <summary>
        /// Gets or sets the lastly edited musical block.
        /// </summary>
        /// <value> Property description. </value>
        public static MusicalBlock LastlyEditedMusicalBlock { get; set; }

        /// <summary>
        /// Gets or sets the lastly edited block model.
        /// </summary>
        /// <value> Property description. </value>
        public static BlockModel LastlyEditedBlockModel { get; set; }
        #endregion

        #region Public properties (Editor selection)

        /// <summary>
        /// Gets or sets Largo File Path.
        /// </summary>
        /// <value>
        /// Property description.
        /// </value>
        public string LargoFilePath { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance has changes.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance has changes; otherwise, <c>false</c>.
        /// </value>
        public bool HasChanges { get; set; }

        /// <summary>
        /// Gets a value indicating whether selection.
        /// </summary>
        /// <value> Property description. </value>
        public bool HasSelection => MusicalSelection?.Points != null && this.MusicalSelection.Points.Any();

        /// <summary>
        /// Gets the selection.
        /// </summary>
        /// <value> Property description. </value>
        public MusicalSelection MusicalSelection { get; }

        /// <summary>
        /// Gets the selected elements.
        /// </summary>
        /// <value> Property description. </value>
        public IList<MusicalElement> SelectedElements
        {
            get
            {
                if (!this.HasSelection) {
                    return null;
                }

                var list = new List<MusicalElement>();
                list.AddRange(this.Block.Body.GetSelectedElements(this.MusicalSelection));

                return list;
            }
        }

        #endregion

        #region Public Properties
        /// <summary>
        /// Gets or sets Musical Block Model.
        /// </summary>
        /// <value>
        /// Property description.
        /// </value>
        public MusicalBlock Block { get; set; }

        /// <summary>
        /// Gets or sets Musical Block Model.
        /// </summary>
        /// <value>
        /// Property description.
        /// </value>
        public BlockModel BlockModel { get; set; }

        /// <summary>
        /// Gets the name of the block model.
        /// </summary>
        /// <value>
        /// The name of the block model.
        /// </value>
        /// <exception cref="System.NotImplementedException">Not Implemented</exception>
        public string BlockModelName
        {
            get
            {
                if (this.BlockModel != null) {
                    return this.BlockModel.FileAndName;  //// givenBlock.FullName; 
                }

                return string.Empty;
            }
        }

        /// <summary>
        /// Gets the display name.
        /// </summary>
        /// <value>
        /// The display name.
        /// </value>
        /// <exception cref="System.NotImplementedException">Not Implemented Exception</exception>
        public string DisplayName
        {
            get
            {
                if (this.Block != null) {
                    return this.Block.NumberNameAndLength;
                }

                if (this.BlockModel != null) {
                    return this.BlockModel.NumberNameAndLength;
                }

                return string.Empty;
            }
        }

        /// <summary>
        /// Gets or sets the content of the editor.
        /// </summary>
        /// <value>
        /// The content of the editor.
        /// </value>
        public EditorContent EditorContent { get; set; }

        /// <summary>
        /// Gets or sets the color of the editor.
        /// </summary>
        /// <value>
        /// The color of the editor.
        /// </value>
        public EditorColor EditorColor { get; set; }

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name of edited document.
        /// </value>
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the description.
        /// </summary>
        /// <value>
        /// The description.
        /// </value>
        public string Description { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether [play on click].
        /// </summary>
        /// <value>
        /// <c>True</c> if [play on click]; otherwise, <c>false</c>.
        /// </value>
        public bool PlayOnClick { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether [synchronize motives].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [synchronize motives]; otherwise, <c>false</c>.
        /// </value>
        public bool SynchronizeMotives { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether [hide mute tracks].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [hide mute tracks]; otherwise, <c>false</c>.
        /// </value>
        public bool HideMuteTracks { get; set; }

        /// <summary>
        /// Gets the fixed tracks.
        /// </summary>
        /// <returns> Returns value. </returns>
        public IList<MusicalTrack> GetFixedTracks
        {
            get
            {
                List<MusicalTrack> tracks = new List<MusicalTrack>();
                for (byte lineIndex = 0; lineIndex < this.Block.Header.NumberOfTracks; lineIndex++) {
                    var track = this.GetTrack(lineIndex);

                    if (track != null && track.Status.Purpose == TrackPurpose.Fixed) { //// track.HasTemplate
                        tracks.Add(track);
                    }
                }

                return tracks;
            }
        }

        /// <summary>
        /// Gets all tracks for composition.
        /// </summary>
        /// <returns> Returns value. </returns>
        public IList<MusicalTrack> GetAllTracksForComposition
        {
            get
            {
                List<MusicalTrack> tracks = new List<MusicalTrack>();

                //// if (composeAll) { mblock.LoadTracksFromModel(blockModel); return; } 
                for (byte lineIndex = 0; lineIndex < this.Block.Header.NumberOfTracks; lineIndex++) {
                    var track = this.GetTrack(lineIndex);
                    if (track == null || track.Status.Purpose == TrackPurpose.Mute || track.Status.Purpose == TrackPurpose.None) {
                        continue;
                    }

                    //// (composeAllTracks && eline.IsImported)
                    if (track.Status.Purpose == TrackPurpose.Fixed) {
                        //// Add original imported track
                        tracks.Add(track);
                    }

                    // ReSharper disable once InvertIf
                    if (track.Status.Purpose == TrackPurpose.Composed) {
                        track.Reset();
                        track.Status.MelodicVariety = new MusicalVariety(MusicalSetup.Singleton);
                        //// 2016/10 newtrack.Status.PlannedTones = new MusicalToneCollection();
                        //// track.Status.HarmonicModalization = MusicalSetup.Singleton.HarmonicModalization;
                        //// LineType = MusicalLineType.Melodic, 
                        //// Purpose = TrackPurpose.Composed,
                        //// Channel = track.Channel  

                        //// 2016 if (eline.Channel != null) { newtrack.Status.Channel = (MidiChannel)eline.Channel; }
                        tracks.Add(track);
                    }
                }

                return tracks;
            }
        }
        #endregion

        #region Private properties
        #endregion

        #region Factory methods
        #endregion

        #region Public methods - Loader
        /// <summary>
        /// Loads the block.
        /// </summary>
        /// <param name="givenBlock">The given block.</param>
        public void LoadBlock(MusicalBlock givenBlock) {
            Contract.Requires(givenBlock != null);
            //// && givenBlock.Strip == null
            if (givenBlock.Body == null) 
            {
                return;
            }

            this.Name = this.BlockModelName;
            this.Block = givenBlock;
            BlockEditor.LastlyEditedMusicalBlock = givenBlock;
            //// this.LoadTracks(this.Block.Strip);
            //// this.LoadBars(this.Block.Body);
            if (this.Block.ContainsMusic) {
                this.Block.Body.SetStatusFromMusic();
            }

            this.Block.Body.DetermineOriginalElements();
            BlockEditor.LastlyEditedBlockModel = this.BlockModel;
        }

        #endregion

        #region Public methods - Composition
        /// <summary>
        /// Composes the music.
        /// </summary>
        /// <returns> Returns value. </returns>
        public MusicalBundle ComposeMusic() {
            var currentBlock = this.Block; //// blockModel.SourceMusicalBlock        
            var mheader = (MusicalHeader)currentBlock.Header.Clone();
            MusicalContext context = new MusicalContext(MusicalSetup.Singleton, mheader);
            var composedBlock = new MusicalBlock {
                //// Number = currentBlock.Number,
                Header = mheader,
                Strip = new MusicalStrip(context)
            };

            ProcessLogger.Singleton.SendLogEvent(currentBlock.Header.Name, LocalizedMusic.String("Initialization..."), 0);
            var tracks = this.GetAllTracksForComposition; //// GetAllTracks(false);
            composedBlock.Strip.SetTracks(tracks);
            composedBlock.Header.NumberOfTracks = tracks.Count;
            composedBlock.ConvertStripToBody(true);

            //// Have to be --- set status from editor !!!!!!!!!!
            //// 2016/03  !!!!!!!!!!!!!
            //// var blockModel = this.Block.ExtractMusicalBlockModel();
            ///// composedBlock.SetMusicalStatus(blockModel);

            var blockStatus = new BlockStatus(currentBlock);
            composedBlock.SetBlockStatus(blockStatus);

            //// TEMPO 2017/01 ?!? //// composedBlock.SetTempoEvents(blockModel.BlockChanges.TempoChanges);
            var tevents = new List<MidiEvent>();
            int deltatime = 0;
            var h = composedBlock.Header;
            var barmididuration = MusicalProperties.BarMidiDuration(h.System.RhythmicOrder, h.Metric.MetricBeat, h.Metric.MetricGround, h.Division);
            foreach (var bar in composedBlock.Body.Bars) {
                if (bar.Status.TempoNumber > 0) {
                    var tevent = new MetaTempo(0, 100) {
                        StartTime = deltatime,
                        Tempo = bar.Status.TempoNumber
                    };

                    tevents.Add(tevent);
                    deltatime += barmididuration;
                }
            }

            if (tevents.Count > 0) {
                composedBlock.Body.TempoEvents = tevents; //// !?!?!? do not work
            }

            //// Main compositional method.
            composedBlock.Body.ComposeMusic();

            ProcessLogger.Singleton.SendLogEvent(currentBlock.Header.Name, LocalizedMusic.String("Finalization..."), 0);
            composedBlock.Strip.WriteBody(composedBlock.Body);
            composedBlock.Strip.CorrectOctaves();

            var filename = currentBlock.FullName;
            int variant = 0;
            while (File.Exists(filename)) {
                variant++;
                filename = currentBlock.FullName + variant.ToString();
            }

            var composedFile = MusicalBundle.GetEnvelopeOfBlock(composedBlock, filename);
            return composedFile;
        }

        #endregion

        /// <summary>
        /// Shifts the line octaves.
        /// </summary>
        /// <param name="numberOfOctaves">The number of octaves.</param>
        public void ShiftOctavesInSelection(int numberOfOctaves) { //// int lineIndex,
            ///// var elements = this.BlockEditor.SelectedLineElements(eline.LineIndex);
            var elements = this.SelectedElements;
            //// var elements = this.SelectedLineElements(lineIndex);
            //// var elements = this.ElementsOfLine(lineIndex);
            if (elements == null) {
                return;
            }

            foreach (var element in elements.Where(element => element != null)) {
                element.ShiftOctave(numberOfOctaves);
            }
        }

        /// <summary>
        /// Selected line elements.
        /// </summary>
        /// <param name="givenLineIndex">Index of the given line.</param>
        /// <returns> Returns value. </returns>
        public IList<MusicalElement> SelectedLineElements(int givenLineIndex) {
            if (!this.HasSelection) {
                return null;
            }

            var list = new List<MusicalElement>();
            list.AddRange(this.Block.Body.GetSelectedElements(this.MusicalSelection, givenLineIndex));

            return list;
        }

        #region Orchestration
        /// <summary>
        /// Orchestrate By Model.
        /// </summary>
        /// <param name="givenStyle">The given style.</param>
        public void OrchestrateBy(MusicalOrchestration givenStyle) {
            if (givenStyle == null || this.Block == null) {
                return;
            }

            this.Block.Orchestration = new MusicalOrchestration(this.Block);
            givenStyle.OrchestrateMusicalBlock(this.Block);
        }

        #endregion

        #region Tracks

        /// <summary>
        /// Gets all tracks.
        /// </summary>
        /// <param name="includeTones">if set to <c>true</c> [include tones].</param>
        /// <returns> Returns value. </returns>
        public IList<MusicalTrack> GetAllTracks(bool includeTones) {
            List<MusicalTrack> tracks = new List<MusicalTrack>();
            for (byte lineIndex = 0; lineIndex < this.Block.Header.NumberOfTracks; lineIndex++) {
                var track = this.GetTrack(lineIndex);
                if (track != null) {
                    var rtrack = includeTones ? track : track.Clone(false);

                    rtrack.Status.MelodicVariety = new MusicalVariety(MusicalSetup.Singleton);
                    //// 2016/10 rtrack.Status.PlannedTones = new MusicalToneCollection();
                    tracks.Add(rtrack);
                }
            }

            return tracks;
        }

        #endregion

        #region Get bars and lines
        /// <summary>
        /// Gets the bar.
        /// </summary>
        /// <param name="givenBarNumber">The given bar number.</param>
        /// <returns> Returns value. </returns>
        public MusicalBar GetBar(int givenBarNumber) {
            return this.Block.Body.GetBar(givenBarNumber);
        }

        /// <summary>
        /// Gets the line.
        /// </summary>
        /// <param name="givenLineIndex">Index of the given line.</param>
        /// <returns>
        /// Returns value.
        /// </returns>
        public MusicalTrack GetTrack(int givenLineIndex) {
            var track = this.Block.Strip.GetTrack(givenLineIndex);
            return track;
        }
        #endregion

        #region Rhythmic
        /// <summary>
        /// Rhythmic of harmony.
        /// </summary>
        /// <returns> Returns value. </returns>
        [UsedImplicitly]
        public IList<RhythmicStructure> RhythmicOfHarmony() {
            var structs = new List<RhythmicStructure>();

            // ReSharper disable once LoopCanBeConvertedToQuery
            foreach (var bar1 in this.Block.Body.Bars.Where(bar1 => bar1 != null)) {
                if (bar1.Status.HarmonicBar == null) {
                    continue;
                }

                var rstr = bar1.Status.HarmonicBar.RhythmicStructure; //// Clone?
                structs.Add(rstr);
            }

            return structs;
        }

        /// <summary>
        /// Reorders the line rhythmic.
        /// </summary>
        /// <param name="lineIndex">The line number.</param>
        /// <param name="blockModel">The block model.</param>
        public void SetRandomRhythm(int lineIndex, BlockModel blockModel) {
            Contract.Requires(blockModel != null);

            var elements = this.Block.Body.ElementsOfLine(lineIndex);
            var master = new ElementMaster(elements);
            var rstructures = blockModel.Core.RhythmicCore.RhythmicStructuresOfMotives;
            master.SetRandomRhythm(rstructures);
        }

        #endregion

        #region Reorder line properties
        /// <summary>
        /// Reorders the line rhythmic.
        /// </summary>
        /// <param name="lineIndex">The line number.</param>
        public void ReorderLineRhythmic(int lineIndex) {
            var elements = this.Block.Body.ElementsOfLine(lineIndex);
            var master = new ElementMaster(elements);
            master.ReorderRhythmic();
        }

        /// <summary>
        /// Reorders the line rhythmic.
        /// </summary>
        /// <param name="lineIndex">The line number.</param>
        public void ReorderLineMelodic(int lineIndex) {
            var elements = this.Block.Body.ElementsOfLine(lineIndex);
            //// var musicalEditorElements = elements as IList<MusicalElement> ?? elements.ToList();
            var master = new ElementMaster(elements);
            master.ReorderMelodic();
        }

        /// <summary>
        /// Reorders the line rhythmic.
        /// </summary>
        public void ReorderLineHarmonic() {
            foreach (var bar1 in this.Block.Body.Bars) {
                if (bar1?.Status.HarmonicBar == null) {
                    continue;
                }

                var bar1c = bar1;
                foreach (var bar2 in this.Block.Body.Bars.Where(bar2 => bar2.Status.HarmonicBar != null && bar2.BarNumber > bar1c.BarNumber).Where(bar2 => MathSupport.RandomNatural(10) < 3)) {
                    bar1.SwapHarmonyWith(bar2);
                }
            }
        }
        #endregion
    }
}